home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / X11R4 / cmds / X / dix / devices.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-02-27  |  31.7 KB  |  1,259 lines
  1. /************************************************************
  2. Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts,
  3. and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
  4.  
  5.                         All Rights Reserved
  6.  
  7. Permission to use, copy, modify, and distribute this software and its 
  8. documentation for any purpose and without fee is hereby granted, 
  9. provided that the above copyright notice appear in all copies and that
  10. both that copyright notice and this permission notice appear in 
  11. supporting documentation, and that the names of Digital or MIT not be
  12. used in advertising or publicity pertaining to distribution of the
  13. software without specific, written prior permission.  
  14.  
  15. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  16. ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  17. DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  18. ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  19. WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  20. ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  21. SOFTWARE.
  22.  
  23. ********************************************************/
  24.  
  25.  
  26. /* $XConsortium: devices.c,v 5.6 90/01/25 14:22:44 rws Exp $ */
  27.  
  28. #include "X.h"
  29. #include "misc.h"
  30. #include "resource.h"
  31. #define NEED_EVENTS
  32. #define NEED_REPLIES
  33. #include "Xproto.h"
  34. #include "windowstr.h"
  35. #include "inputstr.h"
  36. #include "scrnintstr.h"
  37. #include "cursorstr.h"
  38. #include "dixstruct.h"
  39.  
  40. extern InputInfo inputInfo;
  41. extern int (* InitialVector[3]) ();
  42. extern void (* ReplySwapVector[256]) ();
  43. extern void CopySwap32Write(), SwapTimeCoordWrite();
  44. extern void ActivatePointerGrab(), DeactivatePointerGrab();
  45. extern void ActivateKeyboardGrab(), DeactivateKeyboardGrab();
  46. extern Mask EventMaskForClient();
  47.  
  48. DevicePtr
  49. AddInputDevice(deviceProc, autoStart)
  50.     DeviceProc deviceProc;
  51.     Bool autoStart;
  52. {
  53.     register DeviceIntPtr dev;
  54.  
  55.     if (inputInfo.numDevices >= MAX_DEVICES)
  56.     return (DevicePtr)NULL;
  57.     dev = (DeviceIntPtr) xalloc(sizeof(DeviceIntRec));
  58.     if (!dev)
  59.     return (DevicePtr)NULL;
  60.     dev->name = (char *)NULL;
  61.     dev->type = 0;
  62.     dev->id = inputInfo.numDevices;
  63.     inputInfo.numDevices++;
  64.     dev->public.on = FALSE;
  65.     dev->public.processInputProc = NoopDDA;
  66.     dev->public.realInputProc = NoopDDA;
  67.     dev->deviceProc = deviceProc;
  68.     dev->startup = autoStart;
  69.     dev->sync.frozen = FALSE;
  70.     dev->sync.other = NullGrab;
  71.     dev->sync.state = NOT_GRABBED;
  72.     dev->sync.event = (xEvent *) NULL;
  73.     dev->grab = NullGrab;
  74.     dev->fromPassiveGrab = FALSE;
  75.     dev->key = (KeyClassPtr)NULL;
  76.     dev->valuator = (ValuatorClassPtr)NULL;
  77.     dev->button = (ButtonClassPtr)NULL;
  78.     dev->focus = (FocusClassPtr)NULL;
  79.     dev->proximity = (ProximityClassPtr)NULL;
  80.     dev->kbdfeed = (KbdFeedbackPtr)NULL;
  81.     dev->ptrfeed = (PtrFeedbackPtr)NULL;
  82.     dev->intfeed = (IntegerFeedbackPtr)NULL;
  83.     dev->stringfeed = (StringFeedbackPtr)NULL;
  84.     dev->bell = (BellFeedbackPtr)NULL;
  85.     dev->leds = (LedFeedbackPtr)NULL;
  86.     dev->next = inputInfo.off_devices;
  87.     inputInfo.off_devices = dev;
  88.     return &dev->public;
  89. }
  90.  
  91. Bool
  92. EnableDevice(dev)
  93.     register DeviceIntPtr dev;
  94. {
  95.     register DeviceIntPtr *prev;
  96.  
  97.     for (prev = &inputInfo.off_devices;
  98.      *prev && (*prev != dev);
  99.      prev = &(*prev)->next)
  100.     ;
  101.     if ((*prev != dev) || !dev->inited ||
  102.     ((*dev->deviceProc)(dev, DEVICE_ON) != Success))
  103.     return FALSE;
  104.     *prev = dev->next;
  105.     dev->next = inputInfo.devices;
  106.     inputInfo.devices = dev;
  107.     return TRUE;
  108. }
  109.  
  110. Bool
  111. DisableDevice(dev)
  112.     register DeviceIntPtr dev;
  113. {
  114.     register DeviceIntPtr *prev;
  115.  
  116.     for (prev = &inputInfo.devices;
  117.      *prev && (*prev != dev);
  118.      prev = &(*prev)->next)
  119.     ;
  120.     if (*prev != dev)
  121.     return FALSE;
  122.     (void)(*dev->deviceProc)(dev, DEVICE_OFF);
  123.     *prev = dev->next;
  124.     dev->next = inputInfo.off_devices;
  125.     inputInfo.off_devices = dev;
  126.     return TRUE;
  127. }
  128.  
  129. int
  130. InitAndStartDevices()
  131. {
  132.     register DeviceIntPtr dev, next;
  133.  
  134.     for (dev = inputInfo.off_devices; dev; dev = dev->next)
  135.     dev->inited = ((*dev->deviceProc)(dev, DEVICE_INIT) == Success);
  136.     for (dev = inputInfo.off_devices; dev; dev = next)
  137.     {
  138.     next = dev->next;
  139.     if (dev->inited && dev->startup)
  140.         (void)EnableDevice(dev);
  141.     }
  142.     for (dev = inputInfo.devices;
  143.      dev && (dev != inputInfo.keyboard);
  144.      dev = dev->next)
  145.     ;
  146.     if (!dev || (dev != inputInfo.keyboard))
  147.     return BadImplementation;
  148.     for (dev = inputInfo.devices;
  149.      dev && (dev != inputInfo.pointer);
  150.      dev = dev->next)
  151.     ;
  152.     if (!dev || (dev != inputInfo.pointer))
  153.     return BadImplementation;
  154.     return Success;
  155. }
  156.  
  157. static void
  158. CloseDevice(dev)
  159.     register DeviceIntPtr dev;
  160. {
  161.     if (dev->inited)
  162.     (void)(*dev->deviceProc)(dev, DEVICE_CLOSE);
  163.     if (dev->key)
  164.     {
  165.     xfree(dev->key->curKeySyms.map);
  166.     xfree(dev->key->modifierKeyMap);
  167.     xfree(dev->key);
  168.     }
  169.     xfree(dev->valuator);
  170.     xfree(dev->button);
  171.     if (dev->focus)
  172.     {
  173.     xfree(dev->focus->trace);
  174.     xfree(dev->focus);
  175.     }
  176.     xfree(dev->proximity);
  177.     xfree(dev->kbdfeed);
  178.     xfree(dev->ptrfeed);
  179.     xfree(dev->intfeed);
  180.     xfree(dev->stringfeed);
  181.     xfree(dev->bell);
  182.     xfree(dev->leds);
  183.     xfree(dev);
  184. }
  185.  
  186. void
  187. CloseDownDevices()
  188. {
  189.     register DeviceIntPtr dev, next;
  190.  
  191.     for (dev = inputInfo.devices; dev; dev = next)
  192.     {
  193.     next = dev->next;
  194.     CloseDevice(dev);
  195.     }
  196.     for (dev = inputInfo.off_devices; dev; dev = next)
  197.     {
  198.     next = dev->next;
  199.     CloseDevice(dev);
  200.     }
  201. }
  202.  
  203. int
  204. NumMotionEvents()
  205. {
  206.     return inputInfo.pointer->valuator->numMotionEvents;
  207. }
  208.  
  209. void
  210. RegisterPointerDevice(device)
  211.     DevicePtr device;
  212. {
  213.     inputInfo.pointer = (DeviceIntPtr)device;
  214.     device->processInputProc = ProcessPointerEvent;
  215.     device->realInputProc = ProcessPointerEvent;
  216.     ((DeviceIntPtr)device)->ActivateGrab = ActivatePointerGrab;
  217.     ((DeviceIntPtr)device)->DeactivateGrab = DeactivatePointerGrab;
  218. }
  219.  
  220. void
  221. RegisterKeyboardDevice(device)
  222.     DevicePtr device;
  223. {
  224.     inputInfo.keyboard = (DeviceIntPtr)device;
  225.     device->processInputProc = ProcessKeyboardEvent;
  226.     device->realInputProc = ProcessKeyboardEvent;
  227.     ((DeviceIntPtr)device)->ActivateGrab = ActivateKeyboardGrab;
  228.     ((DeviceIntPtr)device)->DeactivateGrab = DeactivateKeyboardGrab;
  229. }
  230.  
  231. DevicePtr
  232. LookupKeyboardDevice()
  233. {
  234.     return &inputInfo.keyboard->public;
  235. }
  236.  
  237. DevicePtr
  238. LookupPointerDevice()
  239. {
  240.     return &inputInfo.pointer->public;
  241. }
  242.  
  243. void
  244. QueryMinMaxKeyCodes(minCode, maxCode)
  245.     KeyCode *minCode, *maxCode;
  246. {
  247.     *minCode = inputInfo.keyboard->key->curKeySyms.minKeyCode;
  248.     *maxCode = inputInfo.keyboard->key->curKeySyms.maxKeyCode;
  249. }
  250.  
  251. Bool
  252. SetKeySymsMap(dst, src)
  253.     register KeySymsPtr dst, src;
  254. {
  255.     int i, j;
  256.     int rowDif = src->minKeyCode - dst->minKeyCode;
  257.            /* if keysym map size changes, grow map first */
  258.  
  259.     if (src->mapWidth < dst->mapWidth)
  260.     {
  261.         for (i = src->minKeyCode; i <= src->maxKeyCode; i++)
  262.     {
  263. #define SI(r, c) (((r-src->minKeyCode)*src->mapWidth) + (c))
  264. #define DI(r, c) (((r - dst->minKeyCode)*dst->mapWidth) + (c))
  265.         for (j = 0; j < src->mapWidth; j++)
  266.         dst->map[DI(i, j)] = src->map[SI(i, j)];
  267.         for (j = src->mapWidth; j < dst->mapWidth; j++)
  268.         dst->map[DI(i, j)] = NoSymbol;
  269. #undef SI
  270. #undef DI
  271.     }
  272.     return TRUE;
  273.     }
  274.     else if (src->mapWidth > dst->mapWidth)
  275.     {
  276.         KeySym *map;
  277.     int bytes = sizeof(KeySym) * src->mapWidth *
  278.             (dst->maxKeyCode - dst->minKeyCode + 1);
  279.         map = (KeySym *)xalloc(bytes);
  280.     if (!map)
  281.         return FALSE;
  282.     bzero((char *)map, bytes);
  283.         if (dst->map)
  284.     {
  285.             for (i = 0; i <= dst->maxKeyCode-dst->minKeyCode; i++)
  286.         bcopy((char *)&dst->map[i*dst->mapWidth],
  287.               (char *)&map[i*src->mapWidth],
  288.               dst->mapWidth * sizeof(KeySym));
  289.         xfree(dst->map);
  290.     }
  291.     dst->mapWidth = src->mapWidth;
  292.     dst->map = map;
  293.     }
  294.     bcopy((char *)src->map,
  295.       (char *)&dst->map[rowDif * dst->mapWidth],
  296.       (int)(src->maxKeyCode - src->minKeyCode + 1) *
  297.       dst->mapWidth * sizeof(KeySym));
  298.     return TRUE;
  299. }
  300.  
  301. static Bool
  302. InitModMap(keyc)
  303.     register KeyClassPtr keyc;
  304. {
  305.     int i, j;
  306.     CARD8 keysPerModifier[8];
  307.     CARD8 mask;
  308.  
  309.     keyc->maxKeysPerModifier = 0;
  310.     for (i = 0; i < 8; i++)
  311.     keysPerModifier[i] = 0;
  312.     for (i = 8; i < MAP_LENGTH; i++)
  313.     {
  314.     for (j = 0, mask = 1; j < 8; j++, mask <<= 1)
  315.     {
  316.         if (mask & keyc->modifierMap[i])
  317.         {
  318.         if (++keysPerModifier[j] > keyc->maxKeysPerModifier)
  319.             keyc->maxKeysPerModifier = keysPerModifier[j];
  320.         }
  321.     }
  322.     }
  323.     keyc->modifierKeyMap = (KeyCode *)xalloc(8*keyc->maxKeysPerModifier);
  324.     if (!keyc->modifierKeyMap && keyc->maxKeysPerModifier)
  325.     return (FALSE);
  326.     bzero((char *)keyc->modifierKeyMap, 8*(int)keyc->maxKeysPerModifier);
  327.     for (i = 0; i < 8; i++)
  328.     keysPerModifier[i] = 0;
  329.     for (i = 8; i < MAP_LENGTH; i++)
  330.     {
  331.     for (j = 0, mask = 1; j < 8; j++, mask <<= 1)
  332.     {
  333.         if (mask & keyc->modifierMap[i])
  334.         {
  335.         keyc->modifierKeyMap[(j*keyc->maxKeysPerModifier) +
  336.                      keysPerModifier[j]] = i;
  337.         keysPerModifier[j]++;
  338.         }
  339.     }
  340.     }
  341.     return TRUE;
  342. }
  343.  
  344. Bool
  345. InitKeyClassDeviceStruct(dev, pKeySyms, pModifiers)
  346.     DeviceIntPtr dev;
  347.     KeySymsPtr pKeySyms;
  348.     CARD8 pModifiers[];
  349. {
  350.     int i;
  351.     register KeyClassPtr keyc;
  352.  
  353.     keyc = (KeyClassPtr)xalloc(sizeof(KeyClassRec));
  354.     if (!keyc)
  355.     return FALSE;
  356.     keyc->curKeySyms.map = (KeySym *)NULL;
  357.     keyc->curKeySyms.mapWidth = 0;
  358.     keyc->curKeySyms.minKeyCode = pKeySyms->minKeyCode;
  359.     keyc->curKeySyms.maxKeyCode = pKeySyms->maxKeyCode;
  360.     keyc->modifierKeyMap = (KeyCode *)NULL;
  361.     keyc->state = 0;
  362.     if (pModifiers)
  363.     bcopy((char *)pModifiers, (char *)keyc->modifierMap, MAP_LENGTH);
  364.     else
  365.     bzero((char *)keyc->modifierMap, MAP_LENGTH);
  366.     bzero((char *)keyc->down, DOWN_LENGTH);
  367.     for (i = 0; i < 8; i++)
  368.     keyc->modifierKeyCount[i] = 0;
  369.     if (!SetKeySymsMap(&keyc->curKeySyms, pKeySyms) || !InitModMap(keyc))
  370.     {
  371.     xfree(keyc->curKeySyms.map);
  372.     xfree(keyc->modifierKeyMap);
  373.     xfree(keyc);
  374.     return FALSE;
  375.     }
  376.     dev->key = keyc;
  377.     return TRUE;
  378. }
  379.  
  380. Bool
  381. InitButtonClassDeviceStruct(dev, numButtons, map)
  382.     register DeviceIntPtr dev;
  383.     int numButtons;
  384.     CARD8 *map;
  385. {
  386.     register ButtonClassPtr butc;
  387.     int i;
  388.  
  389.     butc = (ButtonClassPtr)xalloc(sizeof(ButtonClassRec));
  390.     if (!butc)
  391.     return FALSE;
  392.     butc->numButtons = numButtons;
  393.     for (i = 1; i <= numButtons; i++)
  394.     butc->map[i] = map[i];
  395.     butc->buttonsDown = 0;
  396.     butc->state = 0;
  397.     butc->motionMask = 0;
  398.     bzero((char *)butc->down, DOWN_LENGTH);
  399.     dev->button = butc;
  400.     return TRUE;
  401. }
  402.  
  403. Bool
  404. InitValuatorClassDeviceStruct(dev, numAxes, motionProc, numMotionEvents, mode)
  405.     DeviceIntPtr dev;
  406.     int (*motionProc)();
  407.     int numAxes;
  408.     int numMotionEvents;
  409.     int mode;
  410. {
  411.     register ValuatorClassPtr valc;
  412.  
  413.     valc = (ValuatorClassPtr)xalloc(sizeof(ValuatorClassRec) +
  414.                     numAxes * sizeof(XAxisInfo) +
  415.                     numAxes * sizeof(unsigned short));
  416.     if (!valc)
  417.     return FALSE;
  418.     valc->GetMotionProc = motionProc;
  419.     valc->numMotionEvents = numMotionEvents;
  420.     valc->motionHintWindow = NullWindow;
  421.     valc->numAxes = numAxes;
  422.     valc->mode = mode;
  423.     valc->axes = (XAxisInfoPtr)(valc + 1);
  424.     valc->axisVal = (unsigned short *)(valc->axes +
  425.                        (numAxes * sizeof(XAxisInfo)));
  426.     dev->valuator = valc;
  427.     return TRUE;
  428. }
  429.  
  430. Bool
  431. InitFocusClassDeviceStruct(dev)
  432.     DeviceIntPtr dev;
  433. {
  434.     register FocusClassPtr focc;
  435.  
  436.     focc = (FocusClassPtr)xalloc(sizeof(FocusClassRec));
  437.     if (!focc)
  438.     return FALSE;
  439.     focc->win = PointerRootWin;
  440.     focc->revert = None;
  441.     focc->time = currentTime;
  442.     focc->trace = (WindowPtr *)NULL;
  443.     focc->traceSize = 0;
  444.     focc->traceGood = 0;
  445.     dev->focus = focc;
  446.     return TRUE;
  447. }
  448.  
  449. Bool
  450. InitKbdFeedbackClassDeviceStruct(dev, bellProc, controlProc)
  451.     DeviceIntPtr dev;
  452.     void (*bellProc)();
  453.     void (*controlProc)();
  454. {
  455.     register KbdFeedbackPtr feedc;
  456.  
  457.     feedc = (KbdFeedbackPtr)xalloc(sizeof(KbdFeedbackClassRec));
  458.     if (!feedc)
  459.     return FALSE;
  460.     feedc->BellProc = bellProc;
  461.     feedc->CtrlProc = controlProc;
  462.     feedc->ctrl = defaultKeyboardControl;
  463.     dev->kbdfeed = feedc;
  464.     (*controlProc)(dev, &feedc->ctrl);
  465.     return TRUE;
  466. }
  467.  
  468. Bool
  469. InitPtrFeedbackClassDeviceStruct(dev, controlProc)
  470.     DeviceIntPtr dev;
  471.     void (*controlProc)();
  472. {
  473.     register PtrFeedbackPtr feedc;
  474.  
  475.     feedc = (PtrFeedbackPtr)xalloc(sizeof(PtrFeedbackClassRec));
  476.     if (!feedc)
  477.     return FALSE;
  478.     feedc->CtrlProc = controlProc;
  479.     feedc->ctrl = defaultPointerControl;
  480.     dev->ptrfeed = feedc;
  481.     (*controlProc)(dev, &feedc->ctrl);
  482.     return TRUE;
  483. }
  484.  
  485. Bool
  486. InitPointerDeviceStruct(device, map, numButtons, motionProc, controlProc,
  487.             numMotionEvents)
  488.     DevicePtr device;
  489.     CARD8 *map;
  490.     int numButtons;
  491.     void (*controlProc)();
  492.     int (*motionProc)();
  493.     int numMotionEvents;
  494. {
  495.     DeviceIntPtr dev = (DeviceIntPtr)device;
  496.  
  497.     return(InitButtonClassDeviceStruct(dev, numButtons, map) &&
  498.        InitValuatorClassDeviceStruct(dev, 2, motionProc,
  499.                      numMotionEvents, 0) &&
  500.        InitPtrFeedbackClassDeviceStruct(dev, controlProc));
  501. }
  502.  
  503. Bool
  504. InitKeyboardDeviceStruct(device, pKeySyms, pModifiers, bellProc, controlProc)
  505.     DevicePtr device;
  506.     KeySymsPtr pKeySyms;
  507.     CARD8 pModifiers[];
  508.     void (*bellProc)();
  509.     void (*controlProc)();
  510. {
  511.     DeviceIntPtr dev = (DeviceIntPtr)device;
  512.  
  513.     return(InitKeyClassDeviceStruct(dev, pKeySyms, pModifiers) &&
  514.        InitFocusClassDeviceStruct(dev) &&
  515.        InitKbdFeedbackClassDeviceStruct(dev, bellProc, controlProc));
  516. }
  517.  
  518. int
  519. SendMappingNotify(request, firstKeyCode, count)
  520.     CARD8 request, count;
  521.     KeyCode firstKeyCode;
  522. {
  523.     int i;
  524.     xEvent event;
  525.  
  526.     event.u.u.type = MappingNotify;
  527.     event.u.mappingNotify.request = request;
  528.     if (request == MappingKeyboard)
  529.     {
  530.         event.u.mappingNotify.firstKeyCode = firstKeyCode;
  531.         event.u.mappingNotify.count = count;
  532.     }
  533.     /* 0 is the server client */
  534.     for (i=1; i<currentMaxClients; i++)
  535.         if (clients[i] && ! clients[i]->clientGone &&
  536.         (clients[i]->requestVector != InitialVector))
  537.     {
  538.         event.u.u.sequenceNumber = clients[i]->sequence;
  539.             WriteEventsToClient(clients[i], 1, &event);
  540.     }
  541. }
  542.  
  543. /*
  544.  * n-squared algorithm. n < 255 and don't want to copy the whole thing and
  545.  * sort it to do the checking. How often is it called? Just being lazy?
  546.  */
  547. Bool
  548. BadDeviceMap(buff, length, low, high, errval)
  549.     register BYTE *buff;
  550.     int length;
  551.     unsigned low, high;
  552.     XID *errval;
  553. {
  554.     register int     i, j;
  555.  
  556.     for (i = 0; i < length; i++)
  557.     if (buff[i])               /* only check non-zero elements */
  558.     {
  559.         if ((low > buff[i]) || (high < buff[i]))
  560.         {
  561.         *errval = buff[i];
  562.         return TRUE;
  563.         }
  564.         for (j = i + 1; j < length; j++)
  565.         if (buff[i] == buff[j])
  566.         {
  567.             *errval = buff[i];
  568.             return TRUE;
  569.         }
  570.     }
  571.     return FALSE;
  572. }
  573.  
  574. Bool
  575. AllModifierKeysAreUp(dev, map1, per1, map2, per2)
  576.     register DeviceIntPtr dev;
  577.     register CARD8 *map1, *map2;
  578.     int per1, per2;
  579. {
  580.     register int i, j, k;
  581.     register CARD8 *down = dev->key->down;
  582.  
  583.     for (i = 8; --i >= 0; map2 += per2)
  584.     {
  585.     for (j = per1; --j >= 0; map1++)
  586.     {
  587.         if (*map1 && BitIsOn(down, *map1))
  588.         {
  589.         for (k = per2; (--k >= 0) && (*map1 != map2[k]);)
  590.           ;
  591.         if (k < 0)
  592.             return FALSE;
  593.         }
  594.     }
  595.     }
  596.     return TRUE;
  597. }
  598.  
  599. int 
  600. ProcSetModifierMapping(client)
  601.     ClientPtr client;
  602. {
  603.     xSetModifierMappingReply rep;
  604.     REQUEST(xSetModifierMappingReq);
  605.     KeyCode *inputMap;
  606.     int inputMapLen;
  607.     register int i;
  608.     DeviceIntPtr keybd = inputInfo.keyboard;
  609.     register KeyClassPtr keyc = keybd->key;
  610.     
  611.     REQUEST_AT_LEAST_SIZE(xSetModifierMappingReq);
  612.  
  613.     if (stuff->length != ((stuff->numKeyPerModifier<<1) +
  614.               (sizeof (xSetModifierMappingReq)>>2)))
  615.     return BadLength;
  616.  
  617.     inputMapLen = 8*stuff->numKeyPerModifier;
  618.     inputMap = (KeyCode *)&stuff[1];
  619.  
  620.     /*
  621.      *    Now enforce the restriction that "all of the non-zero keycodes must be
  622.      *    in the range specified by min-keycode and max-keycode in the
  623.      *    connection setup (else a Value error)"
  624.      */
  625.     i = inputMapLen;
  626.     while (i--)
  627.     {
  628.     if (inputMap[i]
  629.         && (inputMap[i] < keyc->curKeySyms.minKeyCode
  630.         || inputMap[i] > keyc->curKeySyms.maxKeyCode))
  631.     {
  632.         client->errorValue = inputMap[i];
  633.         return BadValue;
  634.     }
  635.     }
  636.     rep.type = X_Reply;
  637.     rep.length = 0;
  638.     rep.sequenceNumber = client->sequence;
  639.     rep.success = MappingSuccess;
  640.  
  641.     /*
  642.      *    Now enforce the restriction that none of the old or new
  643.      *    modifier keys may be down while we change the mapping,  and
  644.      *    that the DDX layer likes the choice.
  645.      */
  646.     if (!AllModifierKeysAreUp(keybd, keyc->modifierKeyMap,
  647.                   (int)keyc->maxKeysPerModifier,
  648.                   inputMap, (int)stuff->numKeyPerModifier)
  649.         ||
  650.     !AllModifierKeysAreUp(keybd, inputMap, (int)stuff->numKeyPerModifier,
  651.                   keyc->modifierKeyMap,
  652.                   (int)keyc->maxKeysPerModifier))
  653.     {
  654.     rep.success = MappingBusy;
  655.     }
  656.     else
  657.     {
  658.     for (i = 0; i < inputMapLen; i++)
  659.     {
  660.         if (inputMap[i] && !LegalModifier(inputMap[i], keybd))
  661.         {
  662.         rep.success = MappingFailed;
  663.         break;
  664.         }
  665.     }
  666.     }
  667.  
  668.     if (rep.success == MappingSuccess)
  669.     {
  670.     KeyCode *map;
  671.     /*
  672.      *    Now build the keyboard's modifier bitmap from the
  673.      *    list of keycodes.
  674.      */
  675.     map = (KeyCode *)xalloc(inputMapLen);
  676.     if (!map)
  677.         return BadAlloc;
  678.     if (keyc->modifierKeyMap)
  679.         xfree(keyc->modifierKeyMap);
  680.     keyc->modifierKeyMap = map;
  681.     bcopy((char *)inputMap, (char *)map, inputMapLen);
  682.  
  683.     keyc->maxKeysPerModifier = stuff->numKeyPerModifier;
  684.     for (i = 0; i < MAP_LENGTH; i++)
  685.         keyc->modifierMap[i] = 0;
  686.     for (i = 0; i < inputMapLen; i++)
  687.     {
  688.         if (inputMap[i])
  689.         keyc->modifierMap[inputMap[i]] |=
  690.             (1<<(i/keyc->maxKeysPerModifier));
  691.     }
  692.     }
  693.  
  694.     WriteReplyToClient(client, sizeof(xSetModifierMappingReply), &rep);
  695.  
  696.     if (rep.success == MappingSuccess)
  697.         SendMappingNotify(MappingModifier, 0, 0);
  698.     return(client->noClientException);
  699. }
  700.  
  701. int
  702. ProcGetModifierMapping(client)
  703.     ClientPtr client;
  704. {
  705.     xGetModifierMappingReply rep;
  706.     REQUEST(xReq);
  707.     register KeyClassPtr keyc = inputInfo.keyboard->key;
  708.  
  709.     REQUEST_SIZE_MATCH(xReq);
  710.     rep.type = X_Reply;
  711.     rep.numKeyPerModifier = keyc->maxKeysPerModifier;
  712.     rep.sequenceNumber = client->sequence;
  713.     /* length counts 4 byte quantities - there are 8 modifiers 1 byte big */
  714.     rep.length = keyc->maxKeysPerModifier << 1;
  715.  
  716.     WriteReplyToClient(client, sizeof(xGetModifierMappingReply), &rep);
  717.  
  718.     /* Use the (modified by DDX) map that SetModifierMapping passed in */
  719.     (void)WriteToClient(client, (int)(keyc->maxKeysPerModifier << 3),
  720.             (char *)keyc->modifierKeyMap);
  721.     return client->noClientException;
  722. }
  723.  
  724. int
  725. ProcChangeKeyboardMapping(client)
  726.     ClientPtr client;
  727. {
  728.     REQUEST(xChangeKeyboardMappingReq);
  729.     unsigned len;
  730.     KeySymsRec keysyms;
  731.     register KeySymsPtr curKeySyms = &inputInfo.keyboard->key->curKeySyms;
  732.     REQUEST_AT_LEAST_SIZE(xChangeKeyboardMappingReq);
  733.  
  734.     len = stuff->length - (sizeof(xChangeKeyboardMappingReq) >> 2);  
  735.     if (len != (stuff->keyCodes * stuff->keySymsPerKeyCode))
  736.             return BadLength;
  737.     if ((stuff->firstKeyCode < curKeySyms->minKeyCode) ||
  738.     (stuff->firstKeyCode + stuff->keyCodes - 1 > curKeySyms->maxKeyCode))
  739.     {
  740.         client->errorValue = stuff->firstKeyCode;
  741.         return BadValue;
  742.     }
  743.     if (stuff->keySymsPerKeyCode == 0)
  744.     {
  745.         client->errorValue = 0;
  746.             return BadValue;
  747.     }
  748.     keysyms.minKeyCode = stuff->firstKeyCode;
  749.     keysyms.maxKeyCode = stuff->firstKeyCode + stuff->keyCodes - 1;
  750.     keysyms.mapWidth = stuff->keySymsPerKeyCode;
  751.     keysyms.map = (KeySym *)&stuff[1];
  752.     if (!SetKeySymsMap(curKeySyms, &keysyms))
  753.     return BadAlloc;
  754.     SendMappingNotify(MappingKeyboard, stuff->firstKeyCode, stuff->keyCodes);
  755.     return client->noClientException;
  756.  
  757. }
  758.  
  759. int
  760. ProcSetPointerMapping(client)
  761.     ClientPtr client;
  762. {
  763.     REQUEST(xSetPointerMappingReq);
  764.     BYTE *map;
  765.     xSetPointerMappingReply rep;
  766.     register int i;
  767.     DeviceIntPtr mouse = inputInfo.pointer;
  768.  
  769.     REQUEST_AT_LEAST_SIZE(xSetPointerMappingReq);
  770.     if (stuff->length != (sizeof(xSetPointerMappingReq) + stuff->nElts + 3)>>2)
  771.     return BadLength;
  772.     rep.type = X_Reply;
  773.     rep.length = 0;
  774.     rep.sequenceNumber = client->sequence;
  775.     rep.success = MappingSuccess;
  776.     map = (BYTE *)&stuff[1];
  777.     if (stuff->nElts != mouse->button->numButtons)
  778.     {
  779.     client->errorValue = stuff->nElts;
  780.     return BadValue;
  781.     }
  782.     if (BadDeviceMap(&map[0], (int)stuff->nElts, 1, 255, &client->errorValue))
  783.     return BadValue;
  784.     for (i=0; i < stuff->nElts; i++)
  785.     if ((mouse->button->map[i + 1] != map[i]) &&
  786.         BitIsOn(mouse->button->down, i + 1))
  787.     {
  788.             rep.success = MappingBusy;
  789.         WriteReplyToClient(client, sizeof(xSetPointerMappingReply), &rep);
  790.             return Success;
  791.     }
  792.     for (i = 0; i < stuff->nElts; i++)
  793.     mouse->button->map[i + 1] = map[i];
  794.     WriteReplyToClient(client, sizeof(xSetPointerMappingReply), &rep);
  795.     SendMappingNotify(MappingPointer, 0, 0);
  796.     return Success;
  797. }
  798.  
  799. int
  800. ProcGetKeyboardMapping(client)
  801.     ClientPtr client;
  802. {
  803.     xGetKeyboardMappingReply rep;
  804.     REQUEST(xGetKeyboardMappingReq);
  805.     KeySymsPtr curKeySyms = &inputInfo.keyboard->key->curKeySyms;
  806.  
  807.     REQUEST_SIZE_MATCH(xGetKeyboardMappingReq);
  808.  
  809.     if ((stuff->firstKeyCode < curKeySyms->minKeyCode) ||
  810.         (stuff->firstKeyCode > curKeySyms->maxKeyCode))
  811.     {
  812.     client->errorValue = stuff->firstKeyCode;
  813.     return BadValue;
  814.     }
  815.     if (stuff->firstKeyCode + stuff->count > curKeySyms->maxKeyCode + 1)
  816.     {
  817.     client->errorValue = stuff->count;
  818.         return BadValue;
  819.     }
  820.  
  821.     rep.type = X_Reply;
  822.     rep.sequenceNumber = client->sequence;
  823.     rep.keySymsPerKeyCode = curKeySyms->mapWidth;
  824.     /* length is a count of 4 byte quantities and KeySyms are 4 bytes */
  825.     rep.length = (curKeySyms->mapWidth * stuff->count);
  826.     WriteReplyToClient(client, sizeof(xGetKeyboardMappingReply), &rep);
  827.     client->pSwapReplyFunc = CopySwap32Write;
  828.     WriteSwappedDataToClient(
  829.     client,
  830.     curKeySyms->mapWidth * stuff->count * sizeof(KeySym),
  831.     &curKeySyms->map[(stuff->firstKeyCode - curKeySyms->minKeyCode) *
  832.              curKeySyms->mapWidth]);
  833.  
  834.     return client->noClientException;
  835. }
  836.  
  837. int
  838. ProcGetPointerMapping(client)
  839.     ClientPtr client;
  840. {
  841.     xGetPointerMappingReply rep;
  842.     REQUEST(xReq);
  843.     ButtonClassPtr butc = inputInfo.pointer->button;
  844.  
  845.     REQUEST_SIZE_MATCH(xReq);
  846.     rep.type = X_Reply;
  847.     rep.sequenceNumber = client->sequence;
  848.     rep.nElts = butc->numButtons;
  849.     rep.length = (rep.nElts + (4-1))/4;
  850.     WriteReplyToClient(client, sizeof(xGetPointerMappingReply), &rep);
  851.     (void)WriteToClient(client, (int)rep.nElts, (char *)&butc->map[1]);
  852.     return Success;    
  853. }
  854.  
  855. void
  856. NoteLedState(keybd, led, on)
  857.     DeviceIntPtr keybd;
  858.     int        led;
  859.     Bool    on;
  860. {
  861.     KeybdCtrl *ctrl = &keybd->kbdfeed->ctrl;
  862.     if (on)
  863.     ctrl->leds |= ((Leds)1 << (led - 1));
  864.     else
  865.     ctrl->leds &= ~((Leds)1 << (led - 1));
  866. }
  867.  
  868. int
  869. Ones(mask)                /* HACKMEM 169 */
  870.     Mask mask;
  871. {
  872.     register Mask y;
  873.  
  874.     y = (mask >> 1) &033333333333;
  875.     y = mask - y - ((y >>1) & 033333333333);
  876.     return (((y + (y >> 3)) & 030707070707) % 077);
  877. }
  878.  
  879. int
  880. ProcChangeKeyboardControl (client)
  881.     ClientPtr client;
  882. {
  883. #define DO_ALL    (-1)
  884.     KeybdCtrl ctrl;
  885.     DeviceIntPtr keybd = inputInfo.keyboard;
  886.     XID *vlist;
  887.     int t;
  888.     int led = DO_ALL;
  889.     int key = DO_ALL;
  890.     BITS32 vmask, index;
  891.     int mask, i;
  892.     REQUEST(xChangeKeyboardControlReq);
  893.  
  894.     REQUEST_AT_LEAST_SIZE(xChangeKeyboardControlReq);
  895.     vmask = stuff->mask;
  896.     if (stuff->length !=(sizeof(xChangeKeyboardControlReq)>>2) + Ones(vmask))
  897.     return BadLength;
  898.     vlist = (XID *)&stuff[1];        /* first word of values */
  899.     ctrl = keybd->kbdfeed->ctrl;
  900.     while (vmask)
  901.     {
  902.     index = (BITS32) lowbit (vmask);
  903.     vmask &= ~index;
  904.     switch (index)
  905.     {
  906.     case KBKeyClickPercent: 
  907.         t = (INT8)*vlist;
  908.         vlist++;
  909.         if (t == -1)
  910.         t = defaultKeyboardControl.click;
  911.         else if (t < 0 || t > 100)
  912.         {
  913.         client->errorValue = t;
  914.         return BadValue;
  915.         }
  916.         ctrl.click = t;
  917.         break;
  918.     case KBBellPercent:
  919.         t = (INT8)*vlist;
  920.         vlist++;
  921.         if (t == -1)
  922.         t = defaultKeyboardControl.bell;
  923.         else if (t < 0 || t > 100)
  924.         {
  925.         client->errorValue = t;
  926.         return BadValue;
  927.         }
  928.         ctrl.bell = t;
  929.         break;
  930.     case KBBellPitch:
  931.         t = (INT16)*vlist;
  932.         vlist++;
  933.         if (t == -1)
  934.         t = defaultKeyboardControl.bell_pitch;
  935.         else if (t < 0)
  936.         {
  937.         client->errorValue = t;
  938.         return BadValue;
  939.         }
  940.         ctrl.bell_pitch = t;
  941.         break;
  942.     case KBBellDuration:
  943.         t = (INT16)*vlist;
  944.         vlist++;
  945.         if (t == -1)
  946.         t = defaultKeyboardControl.bell_duration;
  947.         else if (t < 0)
  948.         {
  949.         client->errorValue = t;
  950.         return BadValue;
  951.         }
  952.         ctrl.bell_duration = t;
  953.         break;
  954.     case KBLed:
  955.         led = (CARD8)*vlist;
  956.         vlist++;
  957.         if (led < 1 || led > 32)
  958.         {
  959.         client->errorValue = led;
  960.         return BadValue;
  961.         }
  962.         if (!(stuff->mask & KBLedMode))
  963.         return BadMatch;
  964.         break;
  965.     case KBLedMode:
  966.         t = (CARD8)*vlist;
  967.         vlist++;
  968.         if (t == LedModeOff)
  969.         {
  970.         if (led == DO_ALL)
  971.             ctrl.leds = 0x0;
  972.         else
  973.             ctrl.leds &= ~(((Leds)(1)) << (led - 1));
  974.         }
  975.         else if (t == LedModeOn)
  976.         {
  977.         if (led == DO_ALL)
  978.             ctrl.leds = ~0L;
  979.         else
  980.             ctrl.leds |= (((Leds)(1)) << (led - 1));
  981.         }
  982.         else
  983.         {
  984.         client->errorValue = t;
  985.         return BadValue;
  986.         }
  987.         break;
  988.     case KBKey:
  989.         key = (KeyCode)*vlist;
  990.         vlist++;
  991.         if (key < 8 || key > 255)
  992.         {
  993.         client->errorValue = key;
  994.         return BadValue;
  995.         }
  996.         if (!(stuff->mask & KBAutoRepeatMode))
  997.         return BadMatch;
  998.         break;
  999.     case KBAutoRepeatMode:
  1000.         i = (key >> 3);
  1001.         mask = (1 << (key & 7));
  1002.         t = (CARD8)*vlist;
  1003.         vlist++;
  1004.         if (t == AutoRepeatModeOff)
  1005.         {
  1006.         if (key == DO_ALL)
  1007.             ctrl.autoRepeat = FALSE;
  1008.         else
  1009.             ctrl.autoRepeats[i] &= ~mask;
  1010.         }
  1011.         else if (t == AutoRepeatModeOn)
  1012.         {
  1013.         if (key == DO_ALL)
  1014.             ctrl.autoRepeat = TRUE;
  1015.         else
  1016.             ctrl.autoRepeats[i] |= mask;
  1017.         }
  1018.         else if (t == AutoRepeatModeDefault)
  1019.         {
  1020.         if (key == DO_ALL)
  1021.             ctrl.autoRepeat = defaultKeyboardControl.autoRepeat;
  1022.         else
  1023.             ctrl.autoRepeats[i] &= ~mask;
  1024.             ctrl.autoRepeats[i] =
  1025.                 (ctrl.autoRepeats[i] & ~mask) |
  1026.                 (defaultKeyboardControl.autoRepeats[i] & mask);
  1027.         }
  1028.         else
  1029.         {
  1030.         client->errorValue = t;
  1031.         return BadValue;
  1032.         }
  1033.         break;
  1034.     default:
  1035.         client->errorValue = stuff->mask;
  1036.         return BadValue;
  1037.     }
  1038.     }
  1039.     keybd->kbdfeed->ctrl = ctrl;
  1040.     (*keybd->kbdfeed->CtrlProc)(keybd, &keybd->kbdfeed->ctrl);
  1041.     return Success;
  1042. #undef DO_ALL
  1043. } 
  1044.  
  1045. int
  1046. ProcGetKeyboardControl (client)
  1047.     ClientPtr client;
  1048. {
  1049.     int i;
  1050.     register KeybdCtrl *ctrl = &inputInfo.keyboard->kbdfeed->ctrl;
  1051.     xGetKeyboardControlReply rep;
  1052.     REQUEST(xReq);
  1053.  
  1054.     REQUEST_SIZE_MATCH(xReq);
  1055.     rep.type = X_Reply;
  1056.     rep.length = 5;
  1057.     rep.sequenceNumber = client->sequence;
  1058.     rep.globalAutoRepeat = ctrl->autoRepeat;
  1059.     rep.keyClickPercent = ctrl->click;
  1060.     rep.bellPercent = ctrl->bell;
  1061.     rep.bellPitch = ctrl->bell_pitch;
  1062.     rep.bellDuration = ctrl->bell_duration;
  1063.     rep.ledMask = ctrl->leds;
  1064.     for (i = 0; i < 32; i++)
  1065.     rep.map[i] = ctrl->autoRepeats[i];
  1066.     WriteReplyToClient(client, sizeof(xGetKeyboardControlReply), &rep);
  1067.     return Success;
  1068. } 
  1069.  
  1070. int
  1071. ProcBell(client)
  1072.     ClientPtr client;
  1073. {
  1074.     register DeviceIntPtr keybd = inputInfo.keyboard;
  1075.     int base = keybd->kbdfeed->ctrl.bell;
  1076.     int newpercent;
  1077.     REQUEST(xBellReq);
  1078.     REQUEST_SIZE_MATCH(xBellReq);
  1079.     if (stuff->percent < -100 || stuff->percent > 100)
  1080.     {
  1081.     client->errorValue = stuff->percent;
  1082.     return BadValue;
  1083.     }
  1084.     newpercent = (base * stuff->percent) / 100;
  1085.     if (stuff->percent < 0)
  1086.         newpercent = base + newpercent;
  1087.     else
  1088.         newpercent = base - newpercent + stuff->percent;
  1089.     (*keybd->kbdfeed->BellProc)(newpercent, keybd);
  1090.     return Success;
  1091. } 
  1092.  
  1093. int
  1094. ProcChangePointerControl(client)
  1095.     ClientPtr client;
  1096. {
  1097.     DeviceIntPtr mouse = inputInfo.pointer;
  1098.     PtrCtrl ctrl;        /* might get BadValue part way through */
  1099.     REQUEST(xChangePointerControlReq);
  1100.  
  1101.     REQUEST_SIZE_MATCH(xChangePointerControlReq);
  1102.     ctrl = mouse->ptrfeed->ctrl;
  1103.     if (stuff->doAccel)
  1104.     {
  1105.     if (stuff->accelNum == -1)
  1106.         ctrl.num = defaultPointerControl.num;
  1107.     else if (stuff->accelNum < 0)
  1108.     {
  1109.         client->errorValue = stuff->accelNum;
  1110.         return BadValue;
  1111.     }
  1112.     else ctrl.num = stuff->accelNum;
  1113.     if (stuff->accelDenum == -1)
  1114.         ctrl.den = defaultPointerControl.den;
  1115.     else if (stuff->accelDenum <= 0)
  1116.     {
  1117.         client->errorValue = stuff->accelDenum;
  1118.         return BadValue;
  1119.     }
  1120.     else ctrl.den = stuff->accelDenum;
  1121.     }
  1122.     if (stuff->doThresh)
  1123.     {
  1124.     if (stuff->threshold == -1)
  1125.         ctrl.threshold = defaultPointerControl.threshold;
  1126.     else if (stuff->threshold < 0)
  1127.     {
  1128.         client->errorValue = stuff->threshold;
  1129.         return BadValue;
  1130.     }
  1131.     else ctrl.threshold = stuff->threshold;
  1132.     }
  1133.     mouse->ptrfeed->ctrl = ctrl;
  1134.     (*mouse->ptrfeed->CtrlProc)(mouse, &mouse->ptrfeed->ctrl);
  1135.     return Success;
  1136. } 
  1137.  
  1138. int
  1139. ProcGetPointerControl(client)
  1140.     ClientPtr client;
  1141. {
  1142.     register PtrCtrl *ctrl = &inputInfo.pointer->ptrfeed->ctrl;
  1143.     REQUEST(xReq);
  1144.     xGetPointerControlReply rep;
  1145.  
  1146.     REQUEST_SIZE_MATCH(xReq);
  1147.     rep.type = X_Reply;
  1148.     rep.length = 0;
  1149.     rep.sequenceNumber = client->sequence;
  1150.     rep.threshold = ctrl->threshold;
  1151.     rep.accelNumerator = ctrl->num;
  1152.     rep.accelDenominator = ctrl->den;
  1153.     WriteReplyToClient(client, sizeof(xGenericReply), &rep);
  1154.     return Success;
  1155. }
  1156.  
  1157. void
  1158. MaybeStopHint(dev, client)
  1159.     register DeviceIntPtr dev;
  1160.     ClientPtr client;
  1161. {
  1162.     GrabPtr grab = dev->grab;
  1163.  
  1164.     if ((grab && SameClient(grab, client) &&
  1165.      ((grab->eventMask & PointerMotionHintMask) ||
  1166.       (grab->ownerEvents &&
  1167.        (EventMaskForClient(dev->valuator->motionHintWindow, client) &
  1168.         PointerMotionHintMask)))) ||
  1169.     (!grab &&
  1170.      (EventMaskForClient(dev->valuator->motionHintWindow, client) &
  1171.       PointerMotionHintMask)))
  1172.     dev->valuator->motionHintWindow = NullWindow;
  1173. }
  1174.  
  1175. int
  1176. ProcGetMotionEvents(client)
  1177.     ClientPtr client;
  1178. {
  1179.     WindowPtr pWin;
  1180.     xTimecoord * coords = (xTimecoord *) NULL;
  1181.     xGetMotionEventsReply rep;
  1182.     int     i, count, xmin, xmax, ymin, ymax;
  1183.     unsigned long nEvents;
  1184.     DeviceIntPtr mouse = inputInfo.pointer;
  1185.     TimeStamp start, stop;
  1186.     REQUEST(xGetMotionEventsReq);
  1187.  
  1188.     REQUEST_SIZE_MATCH(xGetMotionEventsReq);
  1189.     pWin = LookupWindow(stuff->window, client);
  1190.     if (!pWin)
  1191.     return BadWindow;
  1192.     if (mouse->valuator->motionHintWindow)
  1193.     MaybeStopHint(mouse, client);
  1194.     rep.type = X_Reply;
  1195.     rep.sequenceNumber = client->sequence;
  1196.     nEvents = 0;
  1197.     start = ClientTimeToServerTime(stuff->start);
  1198.     stop = ClientTimeToServerTime(stuff->stop);
  1199.     if ((CompareTimeStamps(start, stop) != LATER) &&
  1200.     (CompareTimeStamps(start, currentTime) != LATER) &&
  1201.     mouse->valuator->numMotionEvents)
  1202.     {
  1203.     if (CompareTimeStamps(stop, currentTime) == LATER)
  1204.         stop = currentTime;
  1205.     coords = (xTimecoord *)ALLOCATE_LOCAL(mouse->valuator->numMotionEvents
  1206.                           * sizeof(xTimecoord));
  1207.     if (!coords)
  1208.         return BadAlloc;
  1209.     count = (*mouse->valuator->GetMotionProc) (mouse, coords,
  1210.                            start.milliseconds,
  1211.                            stop.milliseconds,
  1212.                            pWin->drawable.pScreen);
  1213.     xmin = pWin->drawable.x - wBorderWidth (pWin);
  1214.     xmax = pWin->drawable.x + (int)pWin->drawable.width +
  1215.         wBorderWidth (pWin);
  1216.     ymin = pWin->drawable.y - wBorderWidth (pWin);
  1217.     ymax = pWin->drawable.y + (int)pWin->drawable.height +
  1218.         wBorderWidth (pWin);
  1219.     for (i = 0; i < count; i++)
  1220.         if ((xmin <= coords[i].x) && (coords[i].x < xmax) &&
  1221.             (ymin <= coords[i].y) && (coords[i].y < ymax))
  1222.         {
  1223.         coords[nEvents].x = coords[i].x - pWin->drawable.x;
  1224.         coords[nEvents].y = coords[i].y - pWin->drawable.y;
  1225.         nEvents++;
  1226.         }
  1227.     }
  1228.     rep.length = nEvents * (sizeof(xTimecoord) >> 2);
  1229.     rep.nEvents = nEvents;
  1230.     WriteReplyToClient(client, sizeof(xGetMotionEventsReply), &rep);
  1231.     if (nEvents)
  1232.     {
  1233.     client->pSwapReplyFunc = SwapTimeCoordWrite;
  1234.     WriteSwappedDataToClient(client, nEvents * sizeof(xTimecoord),
  1235.                  (char *)coords);
  1236.     }
  1237.     if (coords)
  1238.     DEALLOCATE_LOCAL(coords);
  1239.     return Success;
  1240. }
  1241.  
  1242. int
  1243. ProcQueryKeymap(client)
  1244.     ClientPtr client;
  1245. {
  1246.     xQueryKeymapReply rep;
  1247.     int i;
  1248.     CARD8 *down = inputInfo.keyboard->key->down;
  1249.  
  1250.     rep.type = X_Reply;
  1251.     rep.sequenceNumber = client->sequence;
  1252.     rep.length = 2;
  1253.     for (i = 0; i<32; i++)
  1254.     rep.map[i] = down[i];
  1255.     WriteReplyToClient(client, sizeof(xQueryKeymapReply), &rep);
  1256.     return Success;
  1257. }
  1258.  
  1259.